home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_array.py < prev    next >
Text File  |  2005-10-18  |  31KB  |  944 lines
  1. #! /usr/bin/env python
  2. """Test the arraymodule.
  3.    Roger E. Masse
  4. """
  5.  
  6. import unittest
  7. from test import test_support
  8. from weakref import proxy
  9. import array, cStringIO, math
  10.  
  11. tests = [] # list to accumulate all tests
  12. typecodes = "cubBhHiIlLfd"
  13.  
  14. class BadConstructorTest(unittest.TestCase):
  15.  
  16.     def test_constructor(self):
  17.         self.assertRaises(TypeError, array.array)
  18.         self.assertRaises(TypeError, array.array, spam=42)
  19.         self.assertRaises(TypeError, array.array, 'xx')
  20.         self.assertRaises(ValueError, array.array, 'x')
  21.  
  22. tests.append(BadConstructorTest)
  23.  
  24. class BaseTest(unittest.TestCase):
  25.     # Required class attributes (provided by subclasses
  26.     # typecode: the typecode to test
  27.     # example: an initializer usable in the constructor for this type
  28.     # smallerexample: the same length as example, but smaller
  29.     # biggerexample: the same length as example, but bigger
  30.     # outside: An entry that is not in example
  31.     # minitemsize: the minimum guaranteed itemsize
  32.  
  33.     def assertEntryEqual(self, entry1, entry2):
  34.         self.assertEqual(entry1, entry2)
  35.  
  36.     def badtypecode(self):
  37.         # Return a typecode that is different from our own
  38.         return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]
  39.  
  40.     def test_constructor(self):
  41.         a = array.array(self.typecode)
  42.         self.assertEqual(a.typecode, self.typecode)
  43.         self.assert_(a.itemsize>=self.minitemsize)
  44.         self.assertRaises(TypeError, array.array, self.typecode, None)
  45.  
  46.     def test_len(self):
  47.         a = array.array(self.typecode)
  48.         a.append(self.example[0])
  49.         self.assertEqual(len(a), 1)
  50.  
  51.         a = array.array(self.typecode, self.example)
  52.         self.assertEqual(len(a), len(self.example))
  53.  
  54.     def test_buffer_info(self):
  55.         a = array.array(self.typecode, self.example)
  56.         self.assertRaises(TypeError, a.buffer_info, 42)
  57.         bi = a.buffer_info()
  58.         self.assert_(isinstance(bi, tuple))
  59.         self.assertEqual(len(bi), 2)
  60.         self.assert_(isinstance(bi[0], int))
  61.         self.assert_(isinstance(bi[1], int))
  62.         self.assertEqual(bi[1], len(a))
  63.  
  64.     def test_byteswap(self):
  65.         a = array.array(self.typecode, self.example)
  66.         self.assertRaises(TypeError, a.byteswap, 42)
  67.         if a.itemsize in (1, 2, 4, 8):
  68.             b = array.array(self.typecode, self.example)
  69.             b.byteswap()
  70.             if a.itemsize==1:
  71.                 self.assertEqual(a, b)
  72.             else:
  73.                 self.assertNotEqual(a, b)
  74.             b.byteswap()
  75.             self.assertEqual(a, b)
  76.  
  77.     def test_copy(self):
  78.         import copy
  79.         a = array.array(self.typecode, self.example)
  80.         b = copy.copy(a)
  81.         self.assertNotEqual(id(a), id(b))
  82.         self.assertEqual(a, b)
  83.  
  84.     def test_insert(self):
  85.         a = array.array(self.typecode, self.example)
  86.         a.insert(0, self.example[0])
  87.         self.assertEqual(len(a), 1+len(self.example))
  88.         self.assertEqual(a[0], a[1])
  89.         self.assertRaises(TypeError, a.insert)
  90.         self.assertRaises(TypeError, a.insert, None)
  91.         self.assertRaises(TypeError, a.insert, 0, None)
  92.  
  93.         a = array.array(self.typecode, self.example)
  94.         a.insert(-1, self.example[0])
  95.         self.assertEqual(
  96.             a,
  97.             array.array(
  98.                 self.typecode,
  99.                 self.example[:-1] + self.example[:1] + self.example[-1:]
  100.             )
  101.         )
  102.  
  103.         a = array.array(self.typecode, self.example)
  104.         a.insert(-1000, self.example[0])
  105.         self.assertEqual(
  106.             a,
  107.             array.array(self.typecode, self.example[:1] + self.example)
  108.         )
  109.  
  110.         a = array.array(self.typecode, self.example)
  111.         a.insert(1000, self.example[0])
  112.         self.assertEqual(
  113.             a,
  114.             array.array(self.typecode, self.example + self.example[:1])
  115.         )
  116.  
  117.     def test_tofromfile(self):
  118.         a = array.array(self.typecode, 2*self.example)
  119.         self.assertRaises(TypeError, a.tofile)
  120.         self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())
  121.         f = open(test_support.TESTFN, 'wb')
  122.         try:
  123.             a.tofile(f)
  124.             f.close()
  125.             b = array.array(self.typecode)
  126.             f = open(test_support.TESTFN, 'rb')
  127.             self.assertRaises(TypeError, b.fromfile)
  128.             self.assertRaises(
  129.                 TypeError,
  130.                 b.fromfile,
  131.                 cStringIO.StringIO(), len(self.example)
  132.             )
  133.             b.fromfile(f, len(self.example))
  134.             self.assertEqual(b, array.array(self.typecode, self.example))
  135.             self.assertNotEqual(a, b)
  136.             b.fromfile(f, len(self.example))
  137.             self.assertEqual(a, b)
  138.             self.assertRaises(EOFError, b.fromfile, f, 1)
  139.             f.close()
  140.         finally:
  141.             if not f.closed:
  142.                 f.close()
  143.             test_support.unlink(test_support.TESTFN)
  144.  
  145.     def test_tofromlist(self):
  146.         a = array.array(self.typecode, 2*self.example)
  147.         b = array.array(self.typecode)
  148.         self.assertRaises(TypeError, a.tolist, 42)
  149.         self.assertRaises(TypeError, b.fromlist)
  150.         self.assertRaises(TypeError, b.fromlist, 42)
  151.         self.assertRaises(TypeError, b.fromlist, [None])
  152.         b.fromlist(a.tolist())
  153.         self.assertEqual(a, b)
  154.  
  155.     def test_tofromstring(self):
  156.         a = array.array(self.typecode, 2*self.example)
  157.         b = array.array(self.typecode)
  158.         self.assertRaises(TypeError, a.tostring, 42)
  159.         self.assertRaises(TypeError, b.fromstring)
  160.         self.assertRaises(TypeError, b.fromstring, 42)
  161.         b.fromstring(a.tostring())
  162.         self.assertEqual(a, b)
  163.         if a.itemsize>1:
  164.             self.assertRaises(ValueError, b.fromstring, "x")
  165.  
  166.     def test_repr(self):
  167.         a = array.array(self.typecode, 2*self.example)
  168.         self.assertEqual(a, eval(repr(a), {"array": array.array}))
  169.  
  170.         a = array.array(self.typecode)
  171.         self.assertEqual(repr(a), "array('%s')" % self.typecode)
  172.  
  173.     def test_str(self):
  174.         a = array.array(self.typecode, 2*self.example)
  175.         str(a)
  176.  
  177.     def test_cmp(self):
  178.         a = array.array(self.typecode, self.example)
  179.         self.assert_((a == 42) is False)
  180.         self.assert_((a != 42) is True)
  181.  
  182.         self.assert_((a == a) is True)
  183.         self.assert_((a != a) is False)
  184.         self.assert_((a < a) is False)
  185.         self.assert_((a <= a) is True)
  186.         self.assert_((a > a) is False)
  187.         self.assert_((a >= a) is True)
  188.  
  189.         as = array.array(self.typecode, self.smallerexample)
  190.         ab = array.array(self.typecode, self.biggerexample)
  191.  
  192.         self.assert_((a == 2*a) is False)
  193.         self.assert_((a != 2*a) is True)
  194.         self.assert_((a < 2*a) is True)
  195.         self.assert_((a <= 2*a) is True)
  196.         self.assert_((a > 2*a) is False)
  197.         self.assert_((a >= 2*a) is False)
  198.  
  199.         self.assert_((a == as) is False)
  200.         self.assert_((a != as) is True)
  201.         self.assert_((a < as) is False)
  202.         self.assert_((a <= as) is False)
  203.         self.assert_((a > as) is True)
  204.         self.assert_((a >= as) is True)
  205.  
  206.         self.assert_((a == ab) is False)
  207.         self.assert_((a != ab) is True)
  208.         self.assert_((a < ab) is True)
  209.         self.assert_((a <= ab) is True)
  210.         self.assert_((a > ab) is False)
  211.         self.assert_((a >= ab) is False)
  212.  
  213.     def test_add(self):
  214.         a = array.array(self.typecode, self.example) \
  215.             + array.array(self.typecode, self.example[::-1])
  216.         self.assertEqual(
  217.             a,
  218.             array.array(self.typecode, self.example + self.example[::-1])
  219.         )
  220.  
  221.         b = array.array(self.badtypecode())
  222.         self.assertRaises(TypeError, a.__add__, b)
  223.  
  224.         self.assertRaises(TypeError, a.__add__, "bad")
  225.  
  226.     def test_iadd(self):
  227.         a = array.array(self.typecode, self.example[::-1])
  228.         b = a
  229.         a += array.array(self.typecode, 2*self.example)
  230.         self.assert_(a is b)
  231.         self.assertEqual(
  232.             a,
  233.             array.array(self.typecode, self.example[::-1]+2*self.example)
  234.         )
  235.  
  236.         b = array.array(self.badtypecode())
  237.         self.assertRaises(TypeError, a.__add__, b)
  238.  
  239.         self.assertRaises(TypeError, a.__iadd__, "bad")
  240.  
  241.     def test_mul(self):
  242.         a = 5*array.array(self.typecode, self.example)
  243.         self.assertEqual(
  244.             a,
  245.             array.array(self.typecode, 5*self.example)
  246.         )
  247.  
  248.         a = array.array(self.typecode, self.example)*5
  249.         self.assertEqual(
  250.             a,
  251.             array.array(self.typecode, self.example*5)
  252.         )
  253.  
  254.         a = 0*array.array(self.typecode, self.example)
  255.         self.assertEqual(
  256.             a,
  257.             array.array(self.typecode)
  258.         )
  259.  
  260.         a = (-1)*array.array(self.typecode, self.example)
  261.         self.assertEqual(
  262.             a,
  263.             array.array(self.typecode)
  264.         )
  265.  
  266.         self.assertRaises(TypeError, a.__mul__, "bad")
  267.  
  268.     def test_imul(self):
  269.         a = array.array(self.typecode, self.example)
  270.         b = a
  271.  
  272.         a *= 5
  273.         self.assert_(a is b)
  274.         self.assertEqual(
  275.             a,
  276.             array.array(self.typecode, 5*self.example)
  277.         )
  278.  
  279.         a *= 0
  280.         self.assert_(a is b)
  281.         self.assertEqual(a, array.array(self.typecode))
  282.  
  283.         a *= 1000
  284.         self.assert_(a is b)
  285.         self.assertEqual(a, array.array(self.typecode))
  286.  
  287.         a *= -1
  288.         self.assert_(a is b)
  289.         self.assertEqual(a, array.array(self.typecode))
  290.  
  291.         a = array.array(self.typecode, self.example)
  292.         a *= -1
  293.         self.assertEqual(a, array.array(self.typecode))
  294.  
  295.         self.assertRaises(TypeError, a.__imul__, "bad")
  296.  
  297.     def test_getitem(self):
  298.         a = array.array(self.typecode, self.example)
  299.         self.assertEntryEqual(a[0], self.example[0])
  300.         self.assertEntryEqual(a[0L], self.example[0])
  301.         self.assertEntryEqual(a[-1], self.example[-1])
  302.         self.assertEntryEqual(a[-1L], self.example[-1])
  303.         self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
  304.         self.assertEntryEqual(a[-len(self.example)], self.example[0])
  305.         self.assertRaises(TypeError, a.__getitem__)
  306.         self.assertRaises(IndexError, a.__getitem__, len(self.example))
  307.         self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
  308.  
  309.     def test_setitem(self):
  310.         a = array.array(self.typecode, self.example)
  311.         a[0] = a[-1]
  312.         self.assertEntryEqual(a[0], a[-1])
  313.  
  314.         a = array.array(self.typecode, self.example)
  315.         a[0L] = a[-1]
  316.         self.assertEntryEqual(a[0], a[-1])
  317.  
  318.         a = array.array(self.typecode, self.example)
  319.         a[-1] = a[0]
  320.         self.assertEntryEqual(a[0], a[-1])
  321.  
  322.         a = array.array(self.typecode, self.example)
  323.         a[-1L] = a[0]
  324.         self.assertEntryEqual(a[0], a[-1])
  325.  
  326.         a = array.array(self.typecode, self.example)
  327.         a[len(self.example)-1] = a[0]
  328.         self.assertEntryEqual(a[0], a[-1])
  329.  
  330.         a = array.array(self.typecode, self.example)
  331.         a[-len(self.example)] = a[-1]
  332.         self.assertEntryEqual(a[0], a[-1])
  333.  
  334.         self.assertRaises(TypeError, a.__setitem__)
  335.         self.assertRaises(TypeError, a.__setitem__, None)
  336.         self.assertRaises(TypeError, a.__setitem__, 0, None)
  337.         self.assertRaises(
  338.             IndexError,
  339.             a.__setitem__,
  340.             len(self.example), self.example[0]
  341.         )
  342.         self.assertRaises(
  343.             IndexError,
  344.             a.__setitem__,
  345.             -len(self.example)-1, self.example[0]
  346.         )
  347.  
  348.     def test_delitem(self):
  349.         a = array.array(self.typecode, self.example)
  350.         del a[0]
  351.         self.assertEqual(
  352.             a,
  353.             array.array(self.typecode, self.example[1:])
  354.         )
  355.  
  356.         a = array.array(self.typecode, self.example)
  357.         del a[-1]
  358.         self.assertEqual(
  359.             a,
  360.             array.array(self.typecode, self.example[:-1])
  361.         )
  362.  
  363.         a = array.array(self.typecode, self.example)
  364.         del a[len(self.example)-1]
  365.         self.assertEqual(
  366.             a,
  367.             array.array(self.typecode, self.example[:-1])
  368.         )
  369.  
  370.         a = array.array(self.typecode, self.example)
  371.         del a[-len(self.example)]
  372.         self.assertEqual(
  373.             a,
  374.             array.array(self.typecode, self.example[1:])
  375.         )
  376.  
  377.         self.assertRaises(TypeError, a.__delitem__)
  378.         self.assertRaises(TypeError, a.__delitem__, None)
  379.         self.assertRaises(IndexError, a.__delitem__, len(self.example))
  380.         self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
  381.  
  382.     def test_getslice(self):
  383.         a = array.array(self.typecode, self.example)
  384.         self.assertEqual(a[:], a)
  385.  
  386.         self.assertEqual(
  387.             a[1:],
  388.             array.array(self.typecode, self.example[1:])
  389.         )
  390.  
  391.         self.assertEqual(
  392.             a[:1],
  393.             array.array(self.typecode, self.example[:1])
  394.         )
  395.  
  396.         self.assertEqual(
  397.             a[:-1],
  398.             array.array(self.typecode, self.example[:-1])
  399.         )
  400.  
  401.         self.assertEqual(
  402.             a[-1:],
  403.             array.array(self.typecode, self.example[-1:])
  404.         )
  405.  
  406.         self.assertEqual(
  407.             a[-1:-1],
  408.             array.array(self.typecode)
  409.         )
  410.  
  411.         self.assertEqual(
  412.             a[1000:],
  413.             array.array(self.typecode)
  414.         )
  415.         self.assertEqual(a[-1000:], a)
  416.         self.assertEqual(a[:1000], a)
  417.         self.assertEqual(
  418.             a[:-1000],
  419.             array.array(self.typecode)
  420.         )
  421.         self.assertEqual(a[-1000:1000], a)
  422.         self.assertEqual(
  423.             a[2000:1000],
  424.             array.array(self.typecode)
  425.         )
  426.  
  427.     def test_setslice(self):
  428.         a = array.array(self.typecode, self.example)
  429.         a[:1] = a
  430.         self.assertEqual(
  431.             a,
  432.             array.array(self.typecode, self.example + self.example[1:])
  433.         )
  434.  
  435.         a = array.array(self.typecode, self.example)
  436.         a[:-1] = a
  437.         self.assertEqual(
  438.             a,
  439.             array.array(self.typecode, self.example + self.example[-1:])
  440.         )
  441.  
  442.         a = array.array(self.typecode, self.example)
  443.         a[-1:] = a
  444.         self.assertEqual(
  445.             a,
  446.             array.array(self.typecode, self.example[:-1] + self.example)
  447.         )
  448.  
  449.         a = array.array(self.typecode, self.example)
  450.         a[1:] = a
  451.         self.assertEqual(
  452.             a,
  453.             array.array(self.typecode, self.example[:1] + self.example)
  454.         )
  455.  
  456.         a = array.array(self.typecode, self.example)
  457.         a[1:-1] = a
  458.         self.assertEqual(
  459.             a,
  460.             array.array(
  461.                 self.typecode,
  462.                 self.example[:1] + self.example + self.example[-1:]
  463.             )
  464.         )
  465.  
  466.         a = array.array(self.typecode, self.example)
  467.         a[1000:] = a
  468.         self.assertEqual(
  469.             a,
  470.             array.array(self.typecode, 2*self.example)
  471.         )
  472.  
  473.         a = array.array(self.typecode, self.example)
  474.         a[-1000:] = a
  475.         self.assertEqual(
  476.             a,
  477.             array.array(self.typecode, self.example)
  478.         )
  479.  
  480.         a = array.array(self.typecode, self.example)
  481.         a[:1000] = a
  482.         self.assertEqual(
  483.             a,
  484.             array.array(self.typecode, self.example)
  485.         )
  486.  
  487.         a = array.array(self.typecode, self.example)
  488.         a[:-1000] = a
  489.         self.assertEqual(
  490.             a,
  491.             array.array(self.typecode, 2*self.example)
  492.         )
  493.  
  494.         a = array.array(self.typecode, self.example)
  495.         a[1:0] = a
  496.         self.assertEqual(
  497.             a,
  498.             array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
  499.         )
  500.  
  501.         a = array.array(self.typecode, self.example)
  502.         a[2000:1000] = a
  503.         self.assertEqual(
  504.             a,
  505.             array.array(self.typecode, 2*self.example)
  506.         )
  507.  
  508.         a = array.array(self.typecode, self.example)
  509.         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
  510.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
  511.  
  512.         b = array.array(self.badtypecode())
  513.         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
  514.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
  515.  
  516.     def test_index(self):
  517.         example = 2*self.example
  518.         a = array.array(self.typecode, example)
  519.         self.assertRaises(TypeError, a.index)
  520.         for x in example:
  521.             self.assertEqual(a.index(x), example.index(x))
  522.         self.assertRaises(ValueError, a.index, None)
  523.         self.assertRaises(ValueError, a.index, self.outside)
  524.  
  525.     def test_count(self):
  526.         example = 2*self.example
  527.         a = array.array(self.typecode, example)
  528.         self.assertRaises(TypeError, a.count)
  529.         for x in example:
  530.             self.assertEqual(a.count(x), example.count(x))
  531.         self.assertEqual(a.count(self.outside), 0)
  532.         self.assertEqual(a.count(None), 0)
  533.  
  534.     def test_remove(self):
  535.         for x in self.example:
  536.             example = 2*self.example
  537.             a = array.array(self.typecode, example)
  538.             pos = example.index(x)
  539.             example2 = example[:pos] + example[pos+1:]
  540.             a.remove(x)
  541.             self.assertEqual(a, array.array(self.typecode, example2))
  542.  
  543.         a = array.array(self.typecode, self.example)
  544.         self.assertRaises(ValueError, a.remove, self.outside)
  545.  
  546.         self.assertRaises(ValueError, a.remove, None)
  547.  
  548.     def test_pop(self):
  549.         a = array.array(self.typecode)
  550.         self.assertRaises(IndexError, a.pop)
  551.  
  552.         a = array.array(self.typecode, 2*self.example)
  553.         self.assertRaises(TypeError, a.pop, 42, 42)
  554.         self.assertRaises(TypeError, a.pop, None)
  555.         self.assertRaises(IndexError, a.pop, len(a))
  556.         self.assertRaises(IndexError, a.pop, -len(a)-1)
  557.  
  558.         self.assertEntryEqual(a.pop(0), self.example[0])
  559.         self.assertEqual(
  560.             a,
  561.             array.array(self.typecode, self.example[1:]+self.example)
  562.         )
  563.         self.assertEntryEqual(a.pop(1), self.example[2])
  564.         self.assertEqual(
  565.             a,
  566.             array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
  567.         )
  568.         self.assertEntryEqual(a.pop(0), self.example[1])
  569.         self.assertEntryEqual(a.pop(), self.example[-1])
  570.         self.assertEqual(
  571.             a,
  572.             array.array(self.typecode, self.example[3:]+self.example[:-1])
  573.         )
  574.  
  575.     def test_reverse(self):
  576.         a = array.array(self.typecode, self.example)
  577.         self.assertRaises(TypeError, a.reverse, 42)
  578.         a.reverse()
  579.         self.assertEqual(
  580.             a,
  581.             array.array(self.typecode, self.example[::-1])
  582.         )
  583.  
  584.     def test_extend(self):
  585.         a = array.array(self.typecode, self.example)
  586.         self.assertRaises(TypeError, a.extend)
  587.         a.extend(array.array(self.typecode, self.example[::-1]))
  588.         self.assertEqual(
  589.             a,
  590.             array.array(self.typecode, self.example+self.example[::-1])
  591.         )
  592.  
  593.         b = array.array(self.badtypecode())
  594.         self.assertRaises(TypeError, a.extend, b)
  595.  
  596.         a = array.array(self.typecode, self.example)
  597.         a.extend(self.example[::-1])
  598.         self.assertEqual(
  599.             a,
  600.             array.array(self.typecode, self.example+self.example[::-1])
  601.         )
  602.  
  603.     def test_constructor_with_iterable_argument(self):
  604.         a = array.array(self.typecode, iter(self.example))
  605.         b = array.array(self.typecode, self.example)
  606.         self.assertEqual(a, b)
  607.  
  608.         # non-iterable argument
  609.         self.assertRaises(TypeError, array.array, self.typecode, 10)
  610.  
  611.         # pass through errors raised in __iter__
  612.         class A:
  613.             def __iter__(self):
  614.                 raise UnicodeError
  615.         self.assertRaises(UnicodeError, array.array, self.typecode, A())
  616.  
  617.         # pass through errors raised in next()
  618.         def B():
  619.             raise UnicodeError
  620.             yield None
  621.         self.assertRaises(UnicodeError, array.array, self.typecode, B())
  622.  
  623.     def test_coveritertraverse(self):
  624.         try:
  625.             import gc
  626.         except ImportError:
  627.             return
  628.         a = array.array(self.typecode)
  629.         l = [iter(a)]
  630.         l.append(l)
  631.         gc.collect()
  632.  
  633.     def test_buffer(self):
  634.         a = array.array(self.typecode, self.example)
  635.         b = buffer(a)
  636.         self.assertEqual(b[0], a.tostring()[0])
  637.  
  638.     def test_weakref(self):
  639.         s = array.array(self.typecode, self.example)
  640.         p = proxy(s)
  641.         self.assertEqual(p.tostring(), s.tostring())
  642.         s = None
  643.         self.assertRaises(ReferenceError, len, p)
  644.  
  645.     def test_bug_782369(self):
  646.         import sys
  647.         if hasattr(sys, "getrefcount"):
  648.             for i in range(10):
  649.                 b = array.array('B', range(64))
  650.             rc = sys.getrefcount(10)
  651.             for i in range(10):
  652.                 b = array.array('B', range(64))
  653.             self.assertEqual(rc, sys.getrefcount(10))
  654.  
  655.  
  656.  
  657. class StringTest(BaseTest):
  658.  
  659.     def test_setitem(self):
  660.         super(StringTest, self).test_setitem()
  661.         a = array.array(self.typecode, self.example)
  662.         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
  663.  
  664. class CharacterTest(StringTest):
  665.     typecode = 'c'
  666.     example = '\x01azAZ\x00\xfe'
  667.     smallerexample = '\x01azAY\x00\xfe'
  668.     biggerexample = '\x01azAZ\x00\xff'
  669.     outside = '\x33'
  670.     minitemsize = 1
  671.  
  672.     def test_subbclassing(self):
  673.         class EditableString(array.array):
  674.             def __new__(cls, s, *args, **kwargs):
  675.                 return array.array.__new__(cls, 'c', s)
  676.  
  677.             def __init__(self, s, color='blue'):
  678.                 array.array.__init__(self, 'c', s)
  679.                 self.color = color
  680.  
  681.             def strip(self):
  682.                 self[:] = array.array('c', self.tostring().strip())
  683.  
  684.             def __repr__(self):
  685.                 return 'EditableString(%r)' % self.tostring()
  686.  
  687.         s = EditableString("\ttest\r\n")
  688.         s.strip()
  689.         self.assertEqual(s.tostring(), "test")
  690.  
  691.         self.assertEqual(s.color, "blue")
  692.         s.color = "red"
  693.         self.assertEqual(s.color, "red")
  694.         self.assertEqual(s.__dict__.keys(), ["color"])
  695.  
  696.     def test_nounicode(self):
  697.         a = array.array(self.typecode, self.example)
  698.         self.assertRaises(ValueError, a.fromunicode, unicode(''))
  699.         self.assertRaises(ValueError, a.tounicode)
  700.  
  701. tests.append(CharacterTest)
  702.  
  703. if test_support.have_unicode:
  704.     class UnicodeTest(StringTest):
  705.         typecode = 'u'
  706.         example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')
  707.         smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')
  708.         biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')
  709.         outside = unicode('\x33')
  710.         minitemsize = 2
  711.  
  712.         def test_unicode(self):
  713.             self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
  714.  
  715.             a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
  716.             a.fromunicode(unicode(' ', 'ascii'))
  717.             a.fromunicode(unicode('', 'ascii'))
  718.             a.fromunicode(unicode('', 'ascii'))
  719.             a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
  720.             s = a.tounicode()
  721.             self.assertEqual(
  722.                 s,
  723.                 unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
  724.             )
  725.  
  726.             s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
  727.             a = array.array('u', s)
  728.             self.assertEqual(
  729.                 repr(a),
  730.                 r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
  731.             )
  732.  
  733.             self.assertRaises(TypeError, a.fromunicode)
  734.  
  735.     tests.append(UnicodeTest)
  736.  
  737. class NumberTest(BaseTest):
  738.  
  739.     def test_extslice(self):
  740.         a = array.array(self.typecode, range(5))
  741.         self.assertEqual(a[::], a)
  742.         self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
  743.         self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
  744.         self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
  745.         self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
  746.         self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
  747.         self.assertEqual(a[-100:100:], a)
  748.         self.assertEqual(a[100:-100:-1], a[::-1])
  749.         self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
  750.         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
  751.         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
  752.  
  753.     def test_delslice(self):
  754.         a = array.array(self.typecode, range(5))
  755.         del a[::2]
  756.         self.assertEqual(a, array.array(self.typecode, [1,3]))
  757.         a = array.array(self.typecode, range(5))
  758.         del a[1::2]
  759.         self.assertEqual(a, array.array(self.typecode, [0,2,4]))
  760.         a = array.array(self.typecode, range(5))
  761.         del a[1::-2]
  762.         self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
  763.         a = array.array(self.typecode, range(10))
  764.         del a[::1000]
  765.         self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
  766.  
  767.     def test_assignment(self):
  768.         a = array.array(self.typecode, range(10))
  769.         a[::2] = array.array(self.typecode, [42]*5)
  770.         self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
  771.         a = array.array(self.typecode, range(10))
  772.         a[::-4] = array.array(self.typecode, [10]*3)
  773.         self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
  774.         a = array.array(self.typecode, range(4))
  775.         a[::-1] = a
  776.         self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
  777.         a = array.array(self.typecode, range(10))
  778.         b = a[:]
  779.         c = a[:]
  780.         ins = array.array(self.typecode, range(2))
  781.         a[2:3] = ins
  782.         b[slice(2,3)] = ins
  783.         c[2:3:] = ins
  784.  
  785.     def test_iterationcontains(self):
  786.         a = array.array(self.typecode, range(10))
  787.         self.assertEqual(list(a), range(10))
  788.         b = array.array(self.typecode, [20])
  789.         self.assertEqual(a[-1] in a, True)
  790.         self.assertEqual(b[0] not in a, True)
  791.  
  792.     def check_overflow(self, lower, upper):
  793.         # method to be used by subclasses
  794.  
  795.         # should not overflow assigning lower limit
  796.         a = array.array(self.typecode, [lower])
  797.         a[0] = lower
  798.         # should overflow assigning less than lower limit
  799.         self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
  800.         self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
  801.         # should not overflow assigning upper limit
  802.         a = array.array(self.typecode, [upper])
  803.         a[0] = upper
  804.         # should overflow assigning more than upper limit
  805.         self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
  806.         self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
  807.  
  808.     def test_subclassing(self):
  809.         typecode = self.typecode
  810.         class ExaggeratingArray(array.array):
  811.             __slots__ = ['offset']
  812.  
  813.             def __new__(cls, typecode, data, offset):
  814.                 return array.array.__new__(cls, typecode, data)
  815.  
  816.             def __init__(self, typecode, data, offset):
  817.                 self.offset = offset
  818.  
  819.             def __getitem__(self, i):
  820.                 return array.array.__getitem__(self, i) + self.offset
  821.  
  822.         a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
  823.         self.assertEntryEqual(a[0], 7)
  824.  
  825.         self.assertRaises(AttributeError, setattr, a, "color", "blue")
  826.  
  827. class SignedNumberTest(NumberTest):
  828.     example = [-1, 0, 1, 42, 0x7f]
  829.     smallerexample = [-1, 0, 1, 42, 0x7e]
  830.     biggerexample = [-1, 0, 1, 43, 0x7f]
  831.     outside = 23
  832.  
  833.     def test_overflow(self):
  834.         a = array.array(self.typecode)
  835.         lower = -1 * long(pow(2, a.itemsize * 8 - 1))
  836.         upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
  837.         self.check_overflow(lower, upper)
  838.  
  839. class UnsignedNumberTest(NumberTest):
  840.     example = [0, 1, 17, 23, 42, 0xff]
  841.     smallerexample = [0, 1, 17, 23, 42, 0xfe]
  842.     biggerexample = [0, 1, 17, 23, 43, 0xff]
  843.     outside = 0xaa
  844.  
  845.     def test_overflow(self):
  846.         a = array.array(self.typecode)
  847.         lower = 0
  848.         upper = long(pow(2, a.itemsize * 8)) - 1L
  849.         self.check_overflow(lower, upper)
  850.  
  851.  
  852. class ByteTest(SignedNumberTest):
  853.     typecode = 'b'
  854.     minitemsize = 1
  855. tests.append(ByteTest)
  856.  
  857. class UnsignedByteTest(UnsignedNumberTest):
  858.     typecode = 'B'
  859.     minitemsize = 1
  860. tests.append(UnsignedByteTest)
  861.  
  862. class ShortTest(SignedNumberTest):
  863.     typecode = 'h'
  864.     minitemsize = 2
  865. tests.append(ShortTest)
  866.  
  867. class UnsignedShortTest(UnsignedNumberTest):
  868.     typecode = 'H'
  869.     minitemsize = 2
  870. tests.append(UnsignedShortTest)
  871.  
  872. class IntTest(SignedNumberTest):
  873.     typecode = 'i'
  874.     minitemsize = 2
  875. tests.append(IntTest)
  876.  
  877. class UnsignedIntTest(UnsignedNumberTest):
  878.     typecode = 'I'
  879.     minitemsize = 2
  880. tests.append(UnsignedIntTest)
  881.  
  882. class LongTest(SignedNumberTest):
  883.     typecode = 'l'
  884.     minitemsize = 4
  885. tests.append(LongTest)
  886.  
  887. class UnsignedLongTest(UnsignedNumberTest):
  888.     typecode = 'L'
  889.     minitemsize = 4
  890. tests.append(UnsignedLongTest)
  891.  
  892. class FPTest(NumberTest):
  893.     example = [-42.0, 0, 42, 1e5, -1e10]
  894.     smallerexample = [-42.0, 0, 42, 1e5, -2e10]
  895.     biggerexample = [-42.0, 0, 42, 1e5, 1e10]
  896.     outside = 23
  897.  
  898.     def assertEntryEqual(self, entry1, entry2):
  899.         self.assertAlmostEqual(entry1, entry2)
  900.  
  901.     def test_byteswap(self):
  902.         a = array.array(self.typecode, self.example)
  903.         self.assertRaises(TypeError, a.byteswap, 42)
  904.         if a.itemsize in (1, 2, 4, 8):
  905.             b = array.array(self.typecode, self.example)
  906.             b.byteswap()
  907.             if a.itemsize==1:
  908.                 self.assertEqual(a, b)
  909.             else:
  910.                 # On alphas treating the byte swapped bit patters as
  911.                 # floats/doubles results in floating point exceptions
  912.                 # => compare the 8bit string values instead
  913.                 self.assertNotEqual(a.tostring(), b.tostring())
  914.             b.byteswap()
  915.             self.assertEqual(a, b)
  916.  
  917. class FloatTest(FPTest):
  918.     typecode = 'f'
  919.     minitemsize = 4
  920. tests.append(FloatTest)
  921.  
  922. class DoubleTest(FPTest):
  923.     typecode = 'd'
  924.     minitemsize = 8
  925. tests.append(DoubleTest)
  926.  
  927. def test_main(verbose=None):
  928.     import sys
  929.  
  930.     test_support.run_unittest(*tests)
  931.  
  932.     # verify reference counting
  933.     if verbose and hasattr(sys, "gettotalrefcount"):
  934.         import gc
  935.         counts = [None] * 5
  936.         for i in xrange(len(counts)):
  937.             test_support.run_unittest(*tests)
  938.             gc.collect()
  939.             counts[i] = sys.gettotalrefcount()
  940.         print counts
  941.  
  942. if __name__ == "__main__":
  943.     test_main(verbose=True)
  944.